Serverless Application Center for Multi-Cloud Deployment of Serverless Applications

ABSTRACT

A serverless application center is provided for multi-cloud deployment of serverless applications. One method comprises providing source code, obtained from a first user acting in a developer role, for a multi-cloud serverless application in a serverless application repository; deploying, in response to a request from a second user acting in an end user role, source code for the multi-cloud serverless application from the serverless application repository to one or more clouds in plurality of distinct cloud environments based on the request; and implementing role-based access for users acting in said developer role and said end user role. A user interface can allow the second user to (i) review a published list of serverless applications available in the serverless application repository; and/or (ii) search a plurality of serverless applications available in the serverless application repository.

FIELD

The field relates generally to information processing, and more particularly, to the deployment of software applications in a multi-cloud environment.

BACKGROUND

Software applications are increasingly deployed as a collection of functions. In addition, a number of software providers are increasingly using multiple cloud environments to host their applications and/or data. A need remains for improved techniques for deploying serverless applications across multiple cloud environments.

SUMMARY

In one embodiment, a method comprises providing source code, obtained from a first instance of a first user acting in a developer role using a user interface, for at least a portion of a serverless application in a serverless application repository, wherein the serverless application is deployable to one or more clouds of a plurality of distinct cloud environments; deploying, in response to a request from a second user acting in an end user role using a second instance of the user interface, source code for the serverless application from the serverless application repository to one or more of the clouds in plurality of distinct cloud environments based on the request; and implementing role-based access for users acting in said developer role and said end user role.

In some embodiments, the user interface allows the second user to (i) review a published list of serverless applications available in the serverless application repository; and/or (ii) search a plurality of serverless applications available in the serverless application repository. In one or more embodiments, the role-based access comprises a role-based authentication of users acting in said developer role and said end user role.

Other illustrative embodiments include, without limitation, apparatus, systems, methods and computer program products comprising processor-readable storage media.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates an exemplary architecture for a multi-cloud serverless application framework, according to at least one embodiment of the disclosure;

FIG. 2 illustrates an exemplary multi-cloud application environment where a serverless application is deployed, according to one embodiment of the disclosure;

FIG. 3 illustrates an exemplary application registration request sent by a developer to the serverless application framework of FIG. 1, according to at least one embodiment;

FIG. 4 illustrates an exemplary logical architecture for a multi-cloud orchestrator component of the framework, according to an embodiment;

FIG. 5 illustrates an exemplary architecture for a multi-cloud serverless application center, according to at least one embodiment;

FIG. 6 is a flow chart illustrating an exemplary implementation of a serverless application submission process from the perspective of a developer, according to one embodiment of the disclosure;

FIG. 7 is a flow chart illustrating an exemplary implementation of a serverless application evaluation process from the perspective of an administrator of the multi-cloud serverless application center of FIG. 5, according to one or more embodiments;

FIG. 8 is a flow chart illustrating an exemplary implementation of a serverless application deployment process from the perspective of an end user of the multi-cloud serverless application center of FIG. 5, according to at least one embodiment of the disclosure;

FIG. 9 is a flow chart illustrating an exemplary implementation of a multi-cloud role-based serverless application deployment process, according to one embodiment;

FIG. 10 illustrates an exemplary processing platform that may be used to implement at least a portion of one or more embodiments of the disclosure comprising a cloud infrastructure; and

FIG. 11 illustrates another exemplary processing platform that may be used to implement at least a portion of one or more embodiments of the disclosure.

DETAILED DESCRIPTION

Illustrative embodiments of the present disclosure will be described herein with reference to exemplary communication, storage and processing devices. It is to be appreciated, however, that the disclosure is not restricted to use with the particular illustrative configurations shown. One or more embodiments of the disclosure provide a serverless application center for multi-cloud deployment of serverless applications.

Generally, serverless applications are created by software developers as a composition of code fragments corresponding to individual functions that work together to realize the functionalities of an application. An application of this kind is typically deployed in a cloud that offers a Function-as-a-Service (FaaS) environment, such as Azure Functions from Microsoft Corp., or Google Cloud Functions from Google Inc.

U.S. patent application Ser. No. 16/171,554, filed Oct. 26, 2018, entitled “Multi-Cloud Framework for Microservice-Based Applications,” and U.S. patent application Ser. No. 16/554,903, filed Aug. 29, 2019, entitled “Operations Center for Function-Based Applications,” each incorporated by reference herein in its entirety, describe techniques for deploying microservice-based applications across multiple cloud environments. A software Application Programming Interface (API) is provided in some embodiments that allow a developer to deploy a serverless application to multiple clouds, as well as to migrate functions among clouds, in a manner that he or she could, virtually at any moment, track down which functions of which applications were running on which clouds.

One or more embodiments of the present disclosure provide an end-to-end product, referred to in some embodiments as a serverless application center, that serves as a store for multi-cloud serverless applications. End user customers can deploy serverless applications to various cloud providers using button clicks by means of a user interface without significant technical requirements. The disclosed multi-cloud serverless application center allows serverless applications to be shared and reused by several users.

Consider that a developer has an application written to be deployed according to a modern FaaS paradigm: an application is typically a set of functions that can be run, deployed and tested separately in some Cloud environment. The developer can choose one Public Cloud to deploy his or her application and, once deployed, the cloud provider sends regular bills related to resource consumption.

Service prices offered by cloud providers, however, are often dynamic and can change frequently. Thus, a developer may query whether his or her functions are always running on the most cost-effective cloud. A developer may desire to be able to automatically move functions among clouds with minimal effort (e.g., with little, if any, human intervention and/or with little, if any, need to have multiple account subscriptions for different clouds).

Moreover, if some functions of the application are web services (e.g., services that communicate with remote end users via HTTP) that experience regional traffic congestions, it would be nice to be able to easily move these functions to clouds in other regions, again with little, if any, human intervention.

To address the needs of deploying, optimizing and/or monetizing modern serverless applications in multi-cloud environments, an architecture is disclosed for a multi-cloud operations center (e.g., a software system in some embodiments that runs on a server machine and removes the burden from developers of managing multiple clouds in order to harness the benefits from multi-cloud environments).

System Users

In at least one embodiment, the disclosed system is designed to operate with multiple types of users: an administrator, who is responsible for setting up and maintain the system, developers, and end users that deploy serverless applications to one or more clouds and that effectively create serverless applications to be deployed to public clouds. The responsibilities of the administrator, end users and developers in the disclosed system are discussed further below in the following sections.

Applications created by developers can be any kind of applications supported by Cloud FaaS environments, from one-page websites to complex applications whose functions are distributed among various geographic regions.

Administrator

In one or more embodiments, an administrator is an internal member of the disclosed multi-cloud serverless application center who decides whether an application submitted by developers is qualified to be published into our application center the administrator has the following responsibilities. In some embodiments, administrators act as a broker for developers, by creating subscriptions (e.g., accounts) for each Cloud that takes part in the multi-cloud environment (e.g., Azure and/or GCP (Google Cloud Platform)). The disclosed system will use these accounts to deploy, update and/or delete functions created by developers to the clouds, so the developers in some embodiments will not need to create any cloud subscriptions themselves;

-   -   setting up the disclosed system in a server machine and         maintaining its operation;     -   maintaining a list of registered DNS (Domain Name System)         domains and a table of domain redirections within a global DNS         (this mechanism of domain redirection will allow for seamless         migration of HTTP-based functions among clouds, allowing end         users to work with fixed URLs, as discussed further below).

Developers

In some embodiments, developers are customers who develop serverless applications and submit their serverless applications into our application center. There are technical requirements for developers, because they are responsible for developing serverless applications. Developers may want their applications published to several clouds without the burden of registering with various clouds and dealing with them, nor do developers typically want to deal with several billing statements. Developer interactions with the disclosed system in some embodiments include, for example:

-   -   create and/or delete a unique user account in the system,         providing personal and billing information;     -   register and/or de-register applications, providing the address         of a source code repository for each application;     -   initiate application deployment and activate/deactivate Cl/CD;         and     -   receive notifications about application usage and bills related         to it.

End Users

End users are customers who make use of multi-cloud applications published by developers. In some embodiments, there are no technical requirements for end users. End users can use the disclosed multi-cloud serverless application center to deploy multi-cloud serverless applications by several button clicks from the disclosed user interface. End users can employ a user interface of the disclosed serverless application center to (i) review a published list of serverless applications available in the serverless application repository; and/or (ii) search a plurality of serverless applications available in the serverless application repository. In response to a request from an end user of a plurality of end users acting in an end user role using the user interface, source code for the serverless application is deployed from a serverless application repository to one or more of the clouds in plurality of distinct cloud environments based on the request.

One or more embodiments of the disclosure provide an end-to-end software system that allows developers that work with FaaS technologies to take advantage of a multi-cloud environment.

FIG. 1 illustrates an exemplary architecture for a multi-cloud serverless application framework 100, according to an embodiment of the disclosure. As shown in FIG. 1, the exemplary serverless application framework 100 processes requests from a user 105 via a user interface 140, such as requests to register an application 110, requests to register a cloud 120; and/or requests to add, move and/or delete an application 130.

In the example of FIG. 1, the exemplary serverless application framework 100 is comprised of a cloud interface 150, and a plurality of cloud objects 160-A through 160-N for accessing clouds A through N 170-A through 170-N, respectively, such as clouds from Amazon Web Services (AWS), Google Cloud Platform (GCP) and/or Microsoft Azure.

In one or more embodiments, the exemplary serverless application framework 100 demonstrates the following exemplary functionality: Users 105 communicate with the user interface 140, informing what actions they would like to take, including:

register applications 110: users 105 should provide information such as application name and source code repository;

register clouds 120: users 105 should provide cloud account information; and

add/move/delete functions 130: users 105 can add functions of an application into a specific cloud, move functions between different clouds, and/or delete functions of an application from a specific cloud.

In addition, after receiving requests from users 105, the user interface 140 will connect with a specific cloud object component 160 that implements a common cloud interface, and notify the cloud object 170 to take actions according to the requests from the user 105. Further, a specific cloud object 160 will finally interact with the corresponding cloud provider, add functions into a given cloud, move functions between clouds, and/or delete functions from clouds.

With the exemplary framework of FIG. 1, users 105 can deploy multi-cloud serverless applications.

FIG. 2 illustrates an exemplary multi-cloud application environment 200, according to one embodiment of the disclosure. As shown in FIG. 2, the exemplary multi-cloud application environment 200 comprises a multi-cloud framework administration tool 210 that maintains a structural state 220 for one or more applications, such as an application X. Application X comprises five functions, F1, F2, F3, F4 and F5 that run in three different cloud environments 230-1 through 230-3. In one or more embodiments, the application structural state 220 comprises an indication of the cloud environment 230-1 through 230-3 that hosts each function F1 through F5 of the application X, at a given point in time.

Thus, in the example of FIG. 2, cloud environment 230-1 hosts function F2, cloud environment 230-2 hosts functions F3 and F4, and cloud environment 230-3 hosts functions F5 and F1.

In one or more embodiments, the multi-cloud framework administration tool 210 keeps the application structural state 220 up-to-date, as new functions are created or deleted on different cloud environments 230.

The disclosed multi-cloud framework allows for the use of multiple function types. In this manner, a user can initially decide to execute one or more functions in a cloud environment 230 using a first function type and then decide to migrate the one or more functions to another cloud environment 230 using a different function type, as discussed further below. Some exemplary function types are discussed further below in conjunction with FIG. 3.

It is noted that the disclosed multi-cloud framework is optionally extensible and allows for the registering of other function types, as would be apparent to a person of ordinary skill in the art.

As shown in FIG. 2, the exemplary multi-cloud framework administration tool 210 accesses a data store such as a local or global repository 240 comprising a source code 250 for the plurality of functions of the application and deployment instructions (e.g. configuration files, if applicable) 260 for each of the plurality of distinct cloud environments 230-1 through 230-3. Generally, as discussed further below, the exemplary multi-cloud framework administration tool 210 deploys the plurality of functions F1 through F5 of the application X using the structural state 220 of the application, the source code 250 for the plurality of functions F1 through F5 and the deployment instructions (e.g. configuration files, if applicable) 260 for each of the plurality of distinct cloud environments 230.

In various embodiments, the application repository 240 could be any kind of structured data repository, ranging from a folder structure in the operating system file system to a full-fledged commercial Database Management System, depending on organizational concerns such as Information Technology infrastructure norms or security policies. It is important to notice, however, that for multi-cloud Cl/CD to be in place, the application repository must be able to send notifications when the source code for functions registered in the system is modified.

Large companies that are already migrating or intend to migrate applications to the cloud are starting to look at multi-cloud environments as a means of budget savings and avoidance of vendor lock-in. Public clouds offer various services at different prices, and it would be desirable to use different clouds wisely, based on their price offers. At the same time, current industry trends in Cloud Computing point strongly to serverless computing, and cloud providers already provide serverless solutions, e.g., Azure Functions and/or Google Cloud Functions.

There is currently no product in the market, however, that can combine both approaches. In one or more embodiments, the disclosed multi-cloud techniques view applications as a composition of functions to be deployed in serverless cloud environments, and at the same time the functions can be easily migrated from one cloud to another, and this migration is based on cost (or other criteria defined by the users) of the functions.

U.S. patent application Ser. No. 16/171,554, and U.S. patent application Ser. No. 16/554,903, each referenced above, provided a step towards this multi-cloud serverless scenario, by providing an architecture that allows for deployment of serverless applications in multiple clouds and migration of functions among clouds. The present disclosure extends these teachings to provide an end-to-end scenario where this architecture can be fully utilized in the multi-cloud serverless application framework 100 of FIG. 1, with visible benefits for developers and other users that employ it.

In one or more embodiments, a software architecture is provided to implement a serverless application center for multi-cloud deployment of serverless applications. Among other benefits, one or more new features are provided for multi-cloud environments, such as role-based access for users acting in a developer role and/or an end user role. Developers can source code using a user interface, for a serverless application that will be maintained in a serverless application repository. In addition, in response to a request from an end user using the user interface, source code for the serverless application is deployed from the serverless application repository to one or more of the clouds in plurality of distinct cloud environments based on the request.

FIG. 3 illustrates an exemplary application registration request 300 sent by a developer to the multi-cloud serverless application framework 100 of FIG. 1, according to at least one embodiment. As shown in FIG. 3, an exemplary application registration request sent by a developer comprises the following representative information:

-   -   developer identifier (granted during Developer User Account         Creation);     -   application name;     -   application language/runtime (e.g., Jnode6, Python 3.5, etc.);     -   URL for the application source code; and     -   list comprising name and type of each function and specific         information about functions, if needed.

The user specified in the application registration request 300 is validated and the specified application name is evaluated to ensure that it does not yet exist. The functions list can then be passed to a cloud transpiler, so that the cloud transpiler can generate configuration code for different cloud types available in the system (e.g., Azure, GCP) and for different supported function types. Examples of function types can be:

-   -   HTTP-triggered functions, that respond to HTTP requests;     -   time-triggered functions, that must execute at a predefined time         schedule; and     -   storage-triggered functions, that must execute when some public         cloud storage detects new data.

FIG. 4 illustrates an exemplary logical architecture 400 for the disclosed multi-cloud framework, according to an embodiment. As shown in FIG. 4, the exemplary logical architecture 400 comprises a multi-cloud (MC) orchestrator component 410, an application scheduler 430 and a monitor 440.

The MC orchestrator component 410 is the main coordinator of the multi-cloud application environment 200 of FIG. 2. The MC orchestrator component 410 allows a user 405 to interact with the disclosed multi-cloud framework via standard operations so that the multi-cloud framework can provide three exemplary functionalities:

orchestration—keeping the coherence of the application among clouds 230, allowing for deployment, removal or relocation of functions;

resource monitoring—the MC orchestrator component 410 communicates with the monitor 440, which in turn communicates with monitor agents 450-1 through 450-3 for different clouds, so as to collect user-defined metric values; and

application scheduling—the MC orchestrator component 410 communicates with the application scheduler 430 so the application scheduler 430 can use data collected by the monitor 440 to calculate and suggest a move plan back to the MC orchestrator component 410.

One MC orchestrator component 410 can reside on a local desktop and will allow the cloud administrator to manage the multi-cloud application environment 200 of FIG. 2, with help of the other cloud objects depicted in FIG. 4.

In one or more embodiments the MC orchestrator component 410 stores a dictionary containing the structural state 220 of each application:

app_name

-Dict<Cloud, Dict<Service,(active_version, List<Version>)>>

Each time a user calls an operation that is supposed to be performed on an application, the MC orchestrator component 410 uses this dictionary to know which clouds host which functions of that application, and in turn the MC orchestrator component 410 calls the cloud-specific objects to carry on operations specific to the services that each cloud hosts.

The MC orchestrator component 410 object also keeps the URL for the monitor 440 and the application scheduler 430, so the MC orchestrator component 410 can ask these two objects to execute operations related to monitoring and application scheduling. The monitor 440 and the application scheduler 430 reside in principle in the same device as the MC orchestrator component 410, but they can also reside on any cloud, as an alternative implementation, as would be apparent to a person of ordinary skill in the art.

Each cloud 230 can be classified according to a CloudType and, for each cloud 230 that will be part of the multi-cloud application environment 200 of FIG. 2, there is a cloud object 420 running that corresponds to that CloudType. These Cloud objects 420-1 through 420-3 can reside either in their respective Cloud or in the same device as the orchestrator 410—both implementations are possible. The cloud object 420 receives orders from the MC orchestrator component 410 and manages services in the Cloud 230 that the cloud object 420 is responsible for.

In one or more embodiments, there are different implementations of cloud objects 420, one for each supported CloudType. The various cloud objects 420 implement substantially the same list of operations in some embodiments (e.g., the same API that the orchestrator uses to communicate with them). The exemplary logical architecture 400 of FIG. 4 allows for the MC orchestrator component 410 to talk to all clouds 230 using a unified interface, and each cloud object 420 will use native cloud APIs (those of either public or on-premises clouds) to carry out the operations.

In a similar manner as cloud objects 420, each cloud (e.g., either public or on-premises clouds) should have a monitor agent object 450-1 through 450-3 running either on the respective cloud 230 or in the same device as the monitor 440—both implementations are possible. The monitor agent object 450 is responsible for monitoring user-defined metrics related to functions that are allocated on one specific cloud and for sending the metrics data to a user-defined repository, which can optionally reside on the same cloud 230.

While different cloud objects 420 exist for different CloudTypes, different monitor agents 450 also exist for different CloudTypes, because they use the native-provided APIs to carry out their operations. In one or more embodiments, the different monitor agents 450 implement substantially the same API.

The monitor 440 communicates with the different monitor agents 450 in order to order them to start or stop monitoring functions. The monitor 440 receives monitoring reports from each monitor agent 450 responsible for monitoring clouds 230 and aggregates them in reports that are saved to a repository. This repository with aggregated data can be used to send monitoring reports to the MC orchestrator component 410 or the repository can be used by the application scheduler 430 to create move plans.

The monitor 440 keeps information about monitor agents 450, specifically which functions are being monitored by which monitor agents 450 in which cloud 230 and which metrics are being monitored for each function.

As shown in FIG. 4, a monitor repository 460 stores all measures sent by different clouds 230, and the monitor repository 460 organizes the measures in records with the following exemplary structure:

Application_name|service_name|Measure.

The application scheduler 430 uses the data accumulated in the monitor repository 460 used by the monitor 440 to analyze the accumulated data and create a move plan. It also allows the users to create Clots. A clot is a list of functions that cannot be moved separately. Either they are moved together or they do not take part in the move plan.

In some embodiments, the application scheduler 430 is a single object which optionally lives on the same site as the monitor repository 460.

While the MC orchestrator component 410, the application scheduler 430 and the monitor 440 are separate components in the exemplary logical architecture 400 of FIG. 4, other implementations are possible, as would be apparent to a person of ordinary skill in the art. Likewise, while the cloud objects 420 and monitor agent objects 450 are separate components in the exemplary logical architecture 400 of FIG. 4, other implementations are possible, as would be apparent to a person of ordinary skill in the art. The embodiment of FIG. 4 allows for scalability (each logical component being a separate executable code component). Moreover, the framework model can be extended to a model that accommodates multiple monitors 440 and application schedulers 430.

FIG. 5 illustrates an exemplary architecture for a multi-cloud serverless application center 500, according to at least one embodiment. As shown in FIG. 5, the exemplary multi-cloud serverless application center 500 receives user requests from one or more of a developer 510, an end user 520, and an administrator 530, that communicate using a user interface 540. In some embodiments, the user interface 540 can be implemented as a web site that optionally employs role-based access control authentication for each role.

The exemplary multi-cloud serverless application center 500 comprises a backend 550 that further comprises a multi-cloud serverless application framework 560, a serverless application code (SAC) repository 565, a SAC manager 570 and one or more common utilities 580. The exemplary multi-cloud serverless application center 500 interacts with one or more functions 585 of a Cloud A, and a serverless computing platform 590 of Cloud A, where Cloud A is of first cloud environment of a plurality of distinct cloud environments.

In some embodiments, the exemplary multi-cloud serverless application framework 560 is implemented using the techniques discussed above in conjunction with FIGS. 1-3.

In one or more embodiments, the SAC repository 565 is a repository used to store serverless application code published by developers 510. In addition, the SAC manager 570 can be implemented as a logic module to manage the SAC repository 565. When developers 510 publish serverless applications into the application center, the SAC manager 570 uploads the source code of the serverless application into the SAC repository 565. When end users 520 deploy applications into a cloud, the SAC manager 570 will obtain the source code of the deployed serverless application from the SAC repository 565 and sends the source code to the multi-cloud serverless application framework 560.

The common utilities 580 may include, for example, a security module, a log module and/or a routing module.

FIG. 6 is a flow chart illustrating an exemplary implementation of a serverless application submission process 600 from the perspective of a developer, according to one embodiment of the disclosure. As shown in FIG. 6, in the exemplary serverless application submission process 600 from the perspective of a developer, a developer 510 initially develops a serverless application during step 610, and submits the developed serverless application during step 620.

A test is performed during step 630 to determine if the application is approved. If it is determined during step 630 that the application is not approved, then program control returns to step 610 for the developer 510 to further develop the same or a different serverless application, and submit the serverless application for approval.

If it is determined during step 630 that the application is approved, then program control proceeds to step 640 where the serverless application is published. Thus, developers can publish serverless applications into the disclosed multi-cloud serverless application center. When developers publish the serverless application into the disclosed application center, developers push the code into the SAC repository 565, while the source code is not yet deployed to cloud providers.

When developers employ the serverless application submission process 600 to publish serverless applications into the multi-cloud serverless application center 500, the SAC manager module 570 uploads the source code of the serverless application into the SAC repository 565 for each cloud type.

FIG. 7 is a flow chart illustrating an exemplary implementation of a serverless application evaluation process 700 from the perspective of an administrator of the multi-cloud serverless application center of FIG. 5, according to one or more embodiments. As shown in FIG. 7, in the exemplary serverless application evaluation process 700, an administrator 530 receives a notification during step 710 when a serverless application is submitted. Thereafter, the serverless application evaluation process 700 evaluates the application quality during step 720. For example, the serverless application evaluation process 700 can evaluate whether the serverless source code was properly submitted, and whether the submitted code passes one or more of a legal and a compliance check, so as to decide whether to approve the application.

A test is performed during step 730 to determine if the application is qualified. If it is determined during step 730 that the application is not qualified, then the submitted application is disapproved during step 740.

If, however, it is determined during step 730 that the application is qualified, then the submitted application is approved during step 750.

FIG. 8 is a flow chart illustrating an exemplary implementation of a serverless application deployment process 800 from the perspective of an end user of the multi-cloud serverless application center of FIG. 5, according to at least one embodiment of the disclosure. As shown in FIG. 8, in the exemplary serverless application deployment process 800, an end user 520 searches fora serverless application during step 810. Thus, end users 520 can browse serverless applications from the multi-cloud serverless application center, and search for specific applications in which they are interested. Thereafter, the serverless application deployment process 800 deploys the selected serverless application(s) to the appropriate one or more indicated clouds during step 820.

When developers employ the serverless application deployment process 800 to deploy serverless applications into one or more clouds in the multi-cloud environment, the SAC manager module 570 finds the source code for the serverless application for the specific cloud(s) from the SAC repository 565, sends the source code for the serverless application to the multi-cloud serverless application framework module 560, and the multi-cloud serverless application framework module 560 deploys the source code for the serverless application into the corresponding cloud.

In one or more embodiments, end users that deploy serverless applications to a cloud, should first prepare their cloud accounts in advance. End users can be redirected to an authentication page of the cloud providers for identity check purpose using authentication mechanisms.

FIG. 9 is a flow chart illustrating an exemplary implementation of a multi-cloud role-based serverless application deployment process 900, according to one embodiment. As shown in FIG. 9, the exemplary multi-cloud role-based serverless application deployment process 900 initially provides source code, obtained during step 910 from a developer 510 user using a user interface 540, for a serverless application in the SAC repository 565. The serverless application is deployable to one or more clouds of a plurality of distinct cloud environments.

During step 920, the exemplary multi-cloud role-based serverless application deployment process 900 deploys, in response to a request from an end user 520 using the user interface 540, source code for the serverless application from the SAC repository 565 to one or more of the clouds in plurality of distinct cloud environments based on the request.

In addition, the exemplary multi-cloud role-based serverless application deployment process 900 implements role-based access for users acting in a developer role and/or an end user role, during step 930. In some embodiments, the developer 510 can only upload source code for a serverless application to the SAC repository 565. In addition, an end user 520 cannot change anything but can deploy a serverless application to a public cloud.

The disclosed multi-cloud serverless application framework 100 allows end users to deploy serverless applications into a multi-cloud environment. With existing deployment techniques, customers must build applications by themselves, which may be a limiting constraint for some customers. There are several technical requirements for customers including but not limited to, a familiarity with serverless technical background of each cloud provider, a familiarity with programming languages used to build the application, and a capability to understand and develop serverless applications.

In addition, with existing multi-cloud serverless application deployment techniques, target customers are often limited to those with experienced technical skills, while non-technical customers are not able to deploy serverless applications by utilizing this framework.

One or more aspects of the present disclosure recognize that many serverless applications, such as email servers, are general purpose applications, which could be shared and reused by multiple customers. Existing multi-cloud serverless application deployment techniques, however, only allow customers to develop and deploy their own serverless applications in such a multi-cloud environment, in the sense that applications cannot be shared between customers, which often leads to a waste of time and/or resources.

In some embodiments, by differentiating customers into developers and end users, for example, the disclosed multi-cloud serverless application framework 100 allows end users to deploy any serverless application listed in the disclosed multi-cloud serverless application center 500 to a selected cloud, and there is little, if any, technical requirements for end users 520.

In addition, one or more embodiments allow developers 510 and end users 520 to share and reuse serverless applications between each other, since the applications listed by the disclosed multi-cloud serverless application center 500 could be reused by several end users.

One or more embodiments of the disclosure provide improved methods, apparatus and computer program products for a multi-cloud serverless application center 500 for serverless applications. The foregoing applications and associated embodiments should be considered as illustrative only, and numerous other embodiments can be configured using the techniques disclosed herein, in a wide variety of different applications.

It should also be understood that the disclosed multi-cloud techniques for serverless applications, as described herein, can be implemented at least in part in the form of one or more software programs stored in memory and executed by a processor of a processing device such as a computer. As mentioned previously, a memory or other storage device having such program code embodied therein is an example of what is more generally referred to herein as a “computer program product.”

The disclosed multi-cloud techniques for serverless applications may be implemented using one or more processing platforms. One or more of the processing modules or other components may therefore each run on a computer, storage device or other processing platform element. A given such element may be viewed as an example of what is more generally referred to herein as a “processing device.”

As noted above, illustrative embodiments disclosed herein can provide a number of significant advantages relative to conventional arrangements. It is to be appreciated that the particular advantages described above and elsewhere herein are associated with particular illustrative embodiments and need not be present in other embodiments. Also, the particular types of information processing system features and functionality as illustrated and described herein are exemplary only, and numerous other arrangements may be used in other embodiments.

In these and other embodiments, compute services can be offered to cloud infrastructure tenants or other system users as a Platform-as-a-Service (PaaS) offering, although numerous alternative arrangements are possible.

Some illustrative embodiments of a processing platform that may be used to implement at least a portion of an information processing system comprise cloud infrastructure including virtual machines implemented using a hypervisor that runs on physical infrastructure. The cloud infrastructure further comprises sets of applications running on respective ones of the virtual machines under the control of the hypervisor. It is also possible to use multiple hypervisors each providing a set of virtual machines using at least one underlying physical machine. Different sets of virtual machines provided by one or more hypervisors may be utilized in configuring multiple instances of various components of the system.

These and other types of cloud infrastructure can be used to provide what is also referred to herein as a multi-tenant environment. One or more system components such as a cloud-based multi-cloud severless application center 500, or portions thereof, are illustratively implemented for use by tenants of such a multi-tenant environment.

Cloud infrastructure as disclosed herein can include cloud-based systems such as Amazon Web Services (AWS), Google Cloud Platform (GCP) and Microsoft Azure. Virtual machines provided in such systems can be used to implement at least portions of a cloud-based multi-cloud operations platform in illustrative embodiments. The cloud-based systems can include object stores such as Amazon S3, GCP Cloud Storage, and Microsoft Azure Blob Storage.

In some embodiments, the cloud infrastructure additionally or alternatively comprises a plurality of containers implemented using container host devices. For example, a given container of cloud infrastructure illustratively comprises a Docker container or other type of Linux Container (LXC). The containers may run on virtual machines in a multi-tenant environment, although other arrangements are possible. The containers may be utilized to implement a variety of different types of functionality within the storage devices. For example, containers can be used to implement respective processing devices providing compute services of a cloud-based system. Again, containers may be used in combination with other virtualization infrastructure such as virtual machines implemented using a hypervisor.

Illustrative embodiments of processing platforms will now be described in greater detail with reference to FIGS. 10 and 11. These platforms may also be used to implement at least portions of other information processing systems in other embodiments.

FIG. 10 shows an example processing platform comprising cloud infrastructure 1000. The cloud infrastructure 1000 comprises a combination of physical and virtual processing resources that may be utilized to implement at least a portion of the information processing system of the multi-cloud serverless application center 500. The cloud infrastructure 1000 comprises multiple virtual machines (VMs) and/or container sets 1002-1, 1002-2, . . . 1002-L implemented using virtualization infrastructure 1004. The virtualization infrastructure 1004 runs on physical infrastructure 1005, and illustratively comprises one or more hypervisors and/or operating system level virtualization infrastructure. The operating system level virtualization infrastructure illustratively comprises kernel control groups of a Linux operating system or other type of operating system.

The cloud infrastructure 1000 further comprises sets of applications 1010-1, 1010-2, . . . 1010-L running on respective ones of the VMs/container sets 1002-1, 1002-2, . . . 1002-L under the control of the virtualization infrastructure 1004. The VMs/container sets 1002 may comprise respective VMs, respective sets of one or more containers, or respective sets of one or more containers running in VMs.

In some implementations of the FIG. 10 embodiment, the VMs/container sets 1002 comprise respective VMs implemented using virtualization infrastructure 1004 that comprises at least one hypervisor. Such implementations can provide multi-cloud serverless application deployment functionality of the type described above for one or more processes running on a given one of the VMs. For example, each of the VMs can implement multi-cloud control logic and associated source code adaptation for providing multi-cloud deployment functionality for serverless applications for one or more processes running on that particular VM.

An example of a hypervisor platform that may be used to implement a hypervisor within the virtualization infrastructure 1004 is the VMware® vSphere® which may have an associated virtual infrastructure management system such as the VMware® vCenter™. The underlying physical machines may comprise one or more distributed processing platforms that include one or more storage systems.

In other implementations of the FIG. 10 embodiment, the VMs/container sets 1002 comprise respective containers implemented using virtualization infrastructure 1004 that provides operating system level virtualization functionality, such as support for Docker containers running on bare metal hosts, or Docker containers running on VMs. The containers are illustratively implemented using respective kernel control groups of the operating system. Such implementations can provide multi-cloud deployment functionality for serverless applications of the type described above for one or more processes running on different ones of the containers. For example, a container host device supporting multiple containers of one or more container sets can implement one or more instances of multi-cloud control logic and associated role-based access for providing multi-cloud deployment functionality for serverless applications.

As is apparent from the above, one or more of the processing modules or other components of the multi-cloud serverless application center 500 may each run on a computer, server, storage device or other processing platform element. A given such element may be viewed as an example of what is more generally referred to herein as a “processing device.” The cloud infrastructure 1000 shown in FIG. 10 may represent at least a portion of one processing platform. Another example of such a processing platform is processing platform 1100 shown in FIG. 11.

The processing platform 1100 in this embodiment comprises at least a portion of the given system and includes a plurality of processing devices, denoted 1102-1, 1102-2, 1102-3, . . . 1102-K, which communicate with one another over a network 1104. The network 1104 may comprise any type of network, such as a wireless area network (WAN), a local area network (LAN), a satellite network, a telephone or cable network, a cellular network, a wireless network such as WiFi or WiMAX, or various portions or combinations of these and other types of networks.

The processing device 1102-1 in the processing platform 1100 comprises a processor 1110 coupled to a memory 1112. The processor 1110 may comprise a microprocessor, a microcontroller, an application specific integrated circuit (ASIC), a field programmable gate array (FPGA) or other type of processing circuitry, as well as portions or combinations of such circuitry elements, and the memory 1112, which may be viewed as an example of a “processor-readable storage media” storing executable program code of one or more software programs.

Articles of manufacture comprising such processor-readable storage media are considered illustrative embodiments. A given such article of manufacture may comprise, for example, a storage array, a storage disk or an integrated circuit containing RAM, ROM or other electronic memory, or any of a wide variety of other types of computer program products. The term “article of manufacture” as used herein should be understood to exclude transitory, propagating signals. Numerous other types of computer program products comprising processor-readable storage media can be used.

Also included in the processing device 1102-1 is network interface circuitry 1114, which is used to interface the processing device with the network 1104 and other system components, and may comprise conventional transceivers.

The other processing devices 1102 of the processing platform 1100 are assumed to be configured in a manner similar to that shown for processing device 1102-1 in the figure.

Again, the particular processing platform 1100 shown in the figure is presented by way of example only, and the given system may include additional or alternative processing platforms, as well as numerous distinct processing platforms in any combination, with each such platform comprising one or more computers, storage devices or other processing devices.

Multiple elements of an information processing system may be collectively implemented on a common processing platform of the type shown in FIG. 10 or 11, or each such element may be implemented on a separate processing platform.

For example, other processing platforms used to implement illustrative embodiments can comprise different types of virtualization infrastructure, in place of or in addition to virtualization infrastructure comprising virtual machines. Such virtualization infrastructure illustratively includes container-based virtualization infrastructure configured to provide Docker containers or other types of LXCs.

As another example, portions of a given processing platform in some embodiments can comprise converged infrastructure such as VxRail™, VxRack™, VxBlock™, or Vblock® converged infrastructure commercially available from Dell EMC.

It should therefore be understood that in other embodiments different arrangements of additional or alternative elements may be used. At least a subset of these elements may be collectively implemented on a common processing platform, or each such element may be implemented on a separate processing platform.

Also, numerous other arrangements of computers, servers, storage devices or other components are possible in the information processing system. Such components can communicate with other elements of the information processing system over any type of network or other communication media.

As indicated previously, components of an information processing system as disclosed herein can be implemented at least in part in the form of one or more software programs stored in memory and executed by a processor of a processing device. For example, at least portions of the functionality shown in one or more of the figures are illustratively implemented in the form of software running on one or more processing devices.

It should again be emphasized that the above-described embodiments are presented for purposes of illustration only. Many variations and other alternative embodiments may be used. For example, the disclosed techniques are applicable to a wide variety of other types of information processing systems. Also, the particular configurations of system and device elements and associated processing operations illustratively shown in the drawings can be varied in other embodiments. Moreover, the various assumptions made above in the course of describing the illustrative embodiments should also be viewed as exemplary rather than as requirements or limitations of the disclosure. Numerous other alternative embodiments within the scope of the appended claims will be readily apparent to those skilled in the art. 

What is claimed is:
 1. A method, comprising: providing source code, obtained from a first user acting in a developer role using a first instance of a user interface, for at least a portion of a serverless application in a serverless application repository, wherein the serverless application is deployable to one or more clouds of a plurality of distinct cloud environments; deploying, in response to a request from a second user acting in an end user role using a second instance of the user interface, source code for the serverless application from the serverless application repository to one or more of the clouds in plurality of distinct cloud environments based on the request; and implementing role-based access for users acting in said developer role and said end user role, wherein the method is performed by at least one processing device comprising a processor coupled to a memory.
 2. The method of claim 1, further comprising evaluating one or more of a quality, a validity, and a compliance of the provided source code.
 3. The method of claim 1, further comprising publishing the serverless application to the serverless application repository following a predefined approval evaluation.
 4. The method of claim 1, wherein the request from the second user comprises a selection by the second user from a published list of serverless applications available in the serverless application repository.
 5. The method of claim 1, wherein the user interface allows the second user to one or more of (i) review a published list of serverless applications available in the serverless application repository; and (ii) search a plurality of serverless applications available in the serverless application repository.
 6. The method of claim 1, wherein the role-based access comprises a role-based authentication of users acting in said developer role and said end user role.
 7. The method of claim 1, wherein the request from the second user specifies the one or more clouds where the serverless application is deployed.
 8. A system, comprising: a memory; and at least one processing device, coupled to the memory, operative to implement the following steps: providing source code, obtained from a first user acting in a developer role using a first instance of a user interface, for at least a portion of a serverless application in a serverless application repository, wherein the serverless application is deployable to one or more clouds of a plurality of distinct cloud environments; deploying, in response to a request from a second user acting in an end user role using a second instance of the user interface, source code for the serverless application from the serverless application repository to one or more of the clouds in plurality of distinct cloud environments based on the request; and implementing role-based access for users acting in said developer role and said end user role.
 9. The system of claim 8, further comprising publishing the serverless application to the serverless application repository following a predefined approval evaluation.
 10. The system of claim 8, wherein the request from the second user comprises a selection by the second user from a published list of serverless applications available in the serverless application repository.
 11. The system of claim 8, wherein the user interface allows the second user to one or more of (i) review a published list of serverless applications available in the serverless application repository; and (ii) search a plurality of serverless applications available in the serverless application repository.
 12. The system of claim 8, wherein the role-based access comprises a role-based authentication of users acting in said developer role and said end user role.
 13. The system of claim 8, wherein the request from the second user specifies the one or more clouds where the serverless application is deployed.
 14. A computer program product, comprising a tangible machine-readable storage medium having encoded therein executable code of one or more software programs, wherein the one or more software programs when executed by at least one processing device perform the following steps: providing source code, obtained from a first user acting in a developer role using a first instance of a user interface, for at least a portion of a serverless application in a serverless application repository, wherein the serverless application is deployable to one or more clouds of a plurality of distinct cloud environments; deploying, in response to a request from a second user acting in an end user role using a second instance of the user interface, source code for the serverless application from the serverless application repository to one or more of the clouds in plurality of distinct cloud environments based on the request; and implementing role-based access for users acting in said developer role and said end user role.
 15. The computer program product of claim 14, further comprising evaluating one or more of a quality, a validity, and a compliance of the provided source code.
 16. The computer program product of claim 14, further comprising publishing the serverless application to the serverless application repository following a predefined approval evaluation.
 17. The computer program product of claim 14, wherein the request from the second user comprises a selection by the second user from a published list of serverless applications available in the serverless application repository.
 18. The computer program product of claim 14, wherein the user interface allows the second user to one or more of (i) review a published list of serverless applications available in the serverless application repository; and (ii) search a plurality of serverless applications available in the serverless application repository.
 19. The computer program product of claim 14, wherein the role-based access comprises a role-based authentication of users acting in said developer role and said end user role.
 20. The computer program product of claim 14, wherein the request from the second user specifies the one or more clouds where the serverless application is deployed. 